---
title: 語法對比與映射
description: 詳細對比 Python 和 JavaScript 的語法差異，學習如何將 Python 的程式設計思維映射到 JavaScript 語法中，掌握變數、資料型別、控制流等核心概念。
---

# 語法對比與映射

作為 Python 開發者，你已經熟悉了優雅簡潔的 Python 語法。本模組將幫助你系統地理解 JavaScript 語法，並學會如何將 Python 的程式設計思維有效地映射到 JavaScript 中。

## 變數宣告和賦值

### Python vs JavaScript 變數宣告

<PythonEditor title="變數宣告對比" compare={true}>
```python !! py
# Python：簡單的變數賦值
# 變數無需宣告，直接賦值
name = "Alice"
age = 25
is_student = True
score = 95.5

# 動態型別，可以重新賦值為不同型別
name = 123
age = "二十五歲"

# 多重賦值
x, y, z = 1, 2, 3
a = b = c = 0

# 序列解包
numbers = [1, 2, 3, 4, 5]
first, second, *rest = numbers
print(f"第一個: {first}, 第二個: {second}, 其餘: {rest}")

# 交換變數
x, y = y, x

# 全域變數和區域變數
global_var = "全域變數"

def example_function():
    local_var = "區域變數"
    global global_var
    global_var = "修改後的全域變數"
    return local_var
```

```javascript !! js
// JavaScript：需要使用關鍵字宣告變數
// 現代 JavaScript 使用 const/let，避免使用 var
const name = "Alice";  // 常數，不能重新賦值
let age = 25;         // 變數，可以重新賦值
let isStudent = true; // 注意：使用駝峰命名法
let score = 95.5;

// 動態型別，可以重新賦值為不同型別
age = "二十五歲";  // 這是有效的但不推薦

// 多重變數宣告
let x = 1, y = 2, z = 3;
let a, b, c;
a = b = c = 0;

// 陣列解構（類似 Python 解包）
const numbers = [1, 2, 3, 4, 5];
const [first, second, ...rest] = numbers;
console.log(`第一個: ${first}, 第二個: ${second}, 其餘: ${rest}`);

// 變數交換使用解構
[x, y] = [y, x];

// 全域和區域變數
let globalVar = "全域變數";  // 在模組範圍

function exampleFunction() {
    let localVar = "區域變數";
    globalVar = "修改後的全域變數";  // 存取外部範圍
    return localVar;
}
```
</PythonEditor>

### 主要差異

1. **宣告關鍵字**: JavaScript 需要使用 `const`、`let` 或 `var` 來宣告變數
2. **命名慣例**: JavaScript 使用駝峰命名法，Python 使用蛇形命名法
3. **範圍規則**: JavaScript 有函數範圍和區塊範圍，Python 有函數範圍和全域範圍
4. **提升**: JavaScript 變數會被「提升」到其範圍的頂部

## 資料型別對比

### 基本資料型別

<PythonEditor title="基本資料型別" compare={true}>
```python !! py
# Python 基本資料型別
# 數字
integer_num = 42
float_num = 3.14159
complex_num = 3 + 4j

# 字串
single_quote = 'Hello'
double_quote = "World"
triple_quote = """多行
字串在 Python 中"""

# F-字串（格式化字串）
name = "Alice"
age = 25
formatted = f"我的名字是 {name}，我今年 {age} 歲"

# 布林值
is_true = True
is_false = False

# None（空值）
empty_value = None

# 型別檢查
print(type(integer_num))  # <class 'int'>
print(isinstance(float_num, float))  # True

# 型別轉換
str_number = str(42)
int_string = int("123")
float_string = float("3.14")
```

```javascript !! js
// JavaScript 基本資料型別
// 數字（只有一種數字型別）
const integerNum = 42;
const floatNum = 3.14159;
// 沒有內建複數

// 字串
const singleQuote = 'Hello';
const doubleQuote = "World";
const templateLiteral = `多行
字串在 JavaScript 中`;

// 樣板字面值（類似 f-字串）
const name = "Alice";
const age = 25;
const formatted = `我的名字是 ${name}，我今年 ${age} 歲`;

// 布林值
const isTrue = true;
const isFalse = false;

// Null 和 undefined
const emptyValue = null;
let undefinedValue;  // 預設為 undefined

// 型別檢查
console.log(typeof integerNum);  // "number"
console.log(Array.isArray([]));  // 陣列為 true

// 型別轉換
const strNumber = String(42);  // 或 42.toString()
const intString = parseInt("123");
const floatString = parseFloat("3.14");
```
</PythonEditor>

### 複雜資料型別

<PythonEditor title="複雜資料型別" compare={true}>
```python !! py
# Python 集合
# 列表（可變、有序）
fruits = ["apple", "banana", "cherry"]
fruits.append("date")
fruits[0] = "apricot"

# 元組（不可變、有序）
coordinates = (10, 20)
point = 5, 15  # 括號可選

# 字典（可變、鍵值對）
person = {
    "name": "Alice",
    "age": 25,
    "city": "New York"
}
person["email"] = "alice@example.com"

# 集合（可變、唯一值）
unique_numbers = {1, 2, 3, 4, 4}  # {1, 2, 3, 4}

# 列表推導式
squares = [x**2 for x in range(5)]
even_squares = [x**2 for x in range(10) if x % 2 == 0]

# 字典推導式
char_count = {char: word.count(char) for char in "hello"}
```

```javascript !! js
// JavaScript 集合
// 陣列（可變、有序，類似 Python 列表）
const fruits = ["apple", "banana", "cherry"];
fruits.push("date");
fruits[0] = "apricot";

// 沒有內建元組型別，使用陣列或物件
const coordinates = [10, 20];  // 陣列
const point = {x: 5, y: 15};   // 物件

// 物件（類似 Python 字典）
const person = {
    name: "Alice",
    age: 25,
    city: "New York"
};
person.email = "alice@example.com";
person["phone"] = "123-456-7890";  // 括號記法

// Set（ES6+，類似 Python 集合）
const uniqueNumbers = new Set([1, 2, 3, 4, 4]);  // Set {1, 2, 3, 4}

// 陣列方法（類似列表推導式）
const squares = Array.from({length: 5}, (_, i) => i**2);
const evenSquares = Array.from({length: 10}, (_, i) => i)
    .filter(x => x % 2 === 0)
    .map(x => x**2);

// 從陣列建立物件
const word = "hello";
const charCount = {};
for (const char of word) {
    charCount[char] = (charCount[char] || 0) + 1;
}
```
</PythonEditor>

## 控制流語句

### 條件語句

<PythonEditor title="條件語句" compare={true}>
```python !! py
# Python 條件語句
age = 18
score = 85

# 基本 if-elif-else
if age >= 18:
    print("你是成年人")
elif age >= 13:
    print("你是青少年")
else:
    print("你是兒童")

# 多重條件
if score >= 90:
    grade = "A"
elif score >= 80:
    grade = "B"
elif score >= 70:
    grade = "C"
else:
    grade = "F"

# 邏輯運算符
has_license = True
has_car = False

if has_license and age >= 18:
    print("可以開車")

if has_car or has_license:
    print("交通工具可用")

if not has_car:
    print("需要買車")

# 三元運算符
status = "成年人" if age >= 18 else "未成年人"

# 真值性
name = ""
if name:  # 空字串為假值
    print(f"你好，{name}")
else:
    print("未提供姓名")

# None 檢查
value = None
if value is not None:
    print(f"值是 {value}")
```

```javascript !! js
// JavaScript 條件語句
const age = 18;
const score = 85;

// 基本 if-else if-else
if (age >= 18) {
    console.log("你是成年人");
} else if (age >= 13) {
    console.log("你是青少年");
} else {
    console.log("你是兒童");
}

// 多重條件
let grade;
if (score >= 90) {
    grade = "A";
} else if (score >= 80) {
    grade = "B";
} else if (score >= 70) {
    grade = "C";
} else {
    grade = "F";
}

// 邏輯運算符
const hasLicense = true;
const hasCar = false;

if (hasLicense && age >= 18) {
    console.log("可以開車");
}

if (hasCar || hasLicense) {
    console.log("交通工具可用");
}

if (!hasCar) {
    console.log("需要買車");
}

// 三元運算符
const status = age >= 18 ? "成年人" : "未成年人";

// 真值性（類似但規則不同）
const name = "";
if (name) {  // 空字串為假值
    console.log(`你好，${name}`);
} else {
    console.log("未提供姓名");
}

// Null/undefined 檢查
const value = null;
if (value !== null && value !== undefined) {
    console.log(`值是 ${value}`);
}
// 或使用選擇性鏈接
if (value != null) {  // 檢查 null 和 undefined
    console.log(`值是 ${value}`);
}
```
</PythonEditor>

### 迴圈

<PythonEditor title="迴圈語句" compare={true}>
```python !! py
# Python 迴圈
# for 迴圈配合 range
for i in range(5):
    print(f"計數: {i}")

# 帶步長的 for 迴圈
for i in range(0, 10, 2):
    print(f"偶數: {i}")

# 迭代集合的 for 迴圈
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print(f"水果: {fruit}")

# 帶索引的 for 迴圈（enumerate）
for index, fruit in enumerate(fruits):
    print(f"{index}: {fruit}")

# 迭代字典的 for 迴圈
person = {"name": "Alice", "age": 25}
for key in person:
    print(f"{key}: {person[key]}")

for key, value in person.items():
    print(f"{key}: {value}")

# while 迴圈
count = 0
while count < 5:
    print(f"計數: {count}")
    count += 1

# 迴圈控制
for i in range(10):
    if i == 3:
        continue  # 跳過此次迭代
    if i == 7:
        break     # 退出迴圈
    print(i)

# 列表推導式（迴圈替代）
squares = [x**2 for x in range(5)]
even_squares = [x**2 for x in range(10) if x % 2 == 0]
```

```javascript !! js
// JavaScript 迴圈
// 傳統 for 迴圈
for (let i = 0; i < 5; i++) {
    console.log(`計數: ${i}`);
}

// 帶步長的 for 迴圈
for (let i = 0; i < 10; i += 2) {
    console.log(`偶數: ${i}`);
}

// for...of 迴圈（迭代值）
const fruits = ["apple", "banana", "cherry"];
for (const fruit of fruits) {
    console.log(`水果: ${fruit}`);
}

// 帶索引的 for...of（使用 entries()）
for (const [index, fruit] of fruits.entries()) {
    console.log(`${index}: ${fruit}`);
}

// for...in 迴圈（迭代鍵）
const person = {name: "Alice", age: 25};
for (const key in person) {
    console.log(`${key}: ${person[key]}`);
}

// Object.entries() 用於鍵值對
for (const [key, value] of Object.entries(person)) {
    console.log(`${key}: ${value}`);
}

// while 迴圈
let count = 0;
while (count < 5) {
    console.log(`計數: ${count}`);
    count++;
}

// 迴圈控制
for (let i = 0; i < 10; i++) {
    if (i === 3) {
        continue;  // 跳過此次迭代
    }
    if (i === 7) {
        break;     // 退出迴圈
    }
    console.log(i);
}

// 陣列方法（類似推導式）
const squares = Array.from({length: 5}, (_, i) => i**2);
const evenSquares = Array.from({length: 10}, (_, i) => i)
    .filter(x => x % 2 === 0)
    .map(x => x**2);
```
</PythonEditor>

## 函數

### 函數定義和呼叫

<PythonEditor title="函數定義" compare={true}>
```python !! py
# Python 函數
# 基本函數
def greet(name):
    return f"你好，{name}！"

# 帶預設參數的函數
def greet_with_title(name, title="先生/女士"):
    return f"你好，{title} {name}！"

# 多參數函數
def calculate_area(length, width):
    return length * width

# 帶 *args 和 **kwargs 的函數
def flexible_function(*args, **kwargs):
    print("位置參數:", args)
    print("關鍵字參數:", kwargs)
    return sum(args)

# Lambda 函數
square = lambda x: x**2
add = lambda x, y: x + y

# 高階函數
def apply_operation(numbers, operation):
    return [operation(num) for num in numbers]

numbers = [1, 2, 3, 4, 5]
squared = apply_operation(numbers, lambda x: x**2)

# 函數標註（型別提示）
def add_numbers(a: int, b: int) -> int:
    return a + b

# 巢狀函數
def outer_function(x):
    def inner_function(y):
        return x + y
    return inner_function

add_5 = outer_function(5)
result = add_5(3)  # 8
```

```javascript !! js
// JavaScript 函數
// 基本函數（函數宣告）
function greet(name) {
    return `你好，${name}！`;
}

// 帶預設參數的函數（ES6+）
function greetWithTitle(name, title = "先生/女士") {
    return `你好，${title} ${name}！`;
}

// 多參數函數
function calculateArea(length, width) {
    return length * width;
}

// 帶其餘參數的函數（...args）
function flexibleFunction(...args) {
    console.log("參數:", args);
    return args.reduce((sum, num) => sum + num, 0);
}

// 箭頭函數（ES6+，類似 lambda）
const square = x => x**2;
const add = (x, y) => x + y;

// 高階函數
function applyOperation(numbers, operation) {
    return numbers.map(operation);
}

const numbers = [1, 2, 3, 4, 5];
const squared = applyOperation(numbers, x => x**2);

// 函數表達式
const addNumbers = function(a, b) {
    return a + b;
};

// 巢狀函數（閉包）
function outerFunction(x) {
    function innerFunction(y) {
        return x + y;
    }
    return innerFunction;
}

const add5 = outerFunction(5);
const result = add5(3);  // 8

// 立即呼叫函數表達式（IIFE）
const modulePattern = (function() {
    let privateVar = "秘密";
    
    return {
        getSecret: function() {
            return privateVar;
        }
    };
})();
```
</PythonEditor>

## 物件導向程式設計

### 類別和物件

<PythonEditor title="類別和物件" compare={true}>
```python !! py
# Python 類別
class Person:
    # 類別變數
    species = "智人"
    
    def __init__(self, name, age):
        # 例項變數
        self.name = name
        self.age = age
    
    def introduce(self):
        return f"嗨，我是 {self.name}，今年 {self.age} 歲"
    
    def celebrate_birthday(self):
        self.age += 1
        return f"生日快樂！我現在 {self.age} 歲了"
    
    @classmethod
    def get_species(cls):
        return cls.species
    
    @staticmethod
    def is_adult(age):
        return age >= 18

# 繼承
class Student(Person):
    def __init__(self, name, age, student_id):
        super().__init__(name, age)
        self.student_id = student_id
        self.grades = []
    
    def add_grade(self, grade):
        self.grades.append(grade)
    
    def get_average_grade(self):
        if not self.grades:
            return 0
        return sum(self.grades) / len(self.grades)
    
    def introduce(self):  # 方法覆寫
        base_intro = super().introduce()
        return f"{base_intro}。我是學號為 {self.student_id} 的學生"

# 建立例項
person = Person("Alice", 25)
student = Student("Bob", 20, "S12345")

print(person.introduce())
print(student.introduce())
print(f"Alice 是成年人嗎？{Person.is_adult(person.age)}")
```

```javascript !! js
// JavaScript 類別（ES6+）
class Person {
    // 靜態屬性（類別變數）
    static species = "智人";
    
    constructor(name, age) {
        // 例項屬性
        this.name = name;
        this.age = age;
    }
    
    introduce() {
        return `嗨，我是 ${this.name}，今年 ${this.age} 歲`;
    }
    
    celebrateBirthday() {
        this.age++;
        return `生日快樂！我現在 ${this.age} 歲了`;
    }
    
    static getSpecies() {
        return this.species;
    }
    
    static isAdult(age) {
        return age >= 18;
    }
}

// 繼承
class Student extends Person {
    constructor(name, age, studentId) {
        super(name, age);
        this.studentId = studentId;
        this.grades = [];
    }
    
    addGrade(grade) {
        this.grades.push(grade);
    }
    
    getAverageGrade() {
        if (this.grades.length === 0) {
            return 0;
        }
        return this.grades.reduce((sum, grade) => sum + grade, 0) / this.grades.length;
    }
    
    introduce() {  // 方法覆寫
        const baseIntro = super.introduce();
        return `${baseIntro}。我是學號為 ${this.studentId} 的學生`;
    }
}

// 建立例項
const person = new Person("Alice", 25);
const student = new Student("Bob", 20, "S12345");

console.log(person.introduce());
console.log(student.introduce());
console.log(`Alice 是成年人嗎？${Person.isAdult(person.age)}`);

// 替代：物件字面值（用於簡單物件）
const simplePerson = {
    name: "Charlie",
    age: 30,
    introduce() {
        return `嗨，我是 ${this.name}，今年 ${this.age} 歲`;
    }
};
```
</PythonEditor>

## 模組系統

### 匯入和匯出

<PythonEditor title="模組系統" compare={true}>
```python !! py
# Python 模組
# math_utils.py
import math

def calculate_circle_area(radius):
    return math.pi * radius ** 2

def calculate_distance(x1, y1, x2, y2):
    return math.sqrt((x2 - x1)**2 + (y2 - y1)**2)

class Calculator:
    def add(self, a, b):
        return a + b
    
    def multiply(self, a, b):
        return a * b

# 常數
PI = 3.14159
E = 2.71828

# main.py - 不同的匯入方式
# 匯入整個模組
import math_utils
area = math_utils.calculate_circle_area(5)

# 匯入特定函數
from math_utils import calculate_circle_area, Calculator
area = calculate_circle_area(5)
calc = Calculator()

# 帶別名的匯入
from math_utils import calculate_distance as dist
distance = dist(0, 0, 3, 4)

# 匯入全部（不推薦）
from math_utils import *
area = calculate_circle_area(5)

# 內建模組
import os
import json
import datetime

current_dir = os.getcwd()
now = datetime.datetime.now()
```

```javascript !! js
// JavaScript 模組（ES6+）
// mathUtils.js
export function calculateCircleArea(radius) {
    return Math.PI * radius ** 2;
}

export function calculateDistance(x1, y1, x2, y2) {
    return Math.sqrt((x2 - x1)**2 + (y2 - y1)**2);
}

export class Calculator {
    add(a, b) {
        return a + b;
    }
    
    multiply(a, b) {
        return a * b;
    }
}

// 命名匯出
export const PI = 3.14159;
export const E = 2.71828;

// 預設匯出
export default class MathUtility {
    static factorial(n) {
        return n <= 1 ? 1 : n * this.factorial(n - 1);
    }
}

// main.js - 不同的匯入方式
// 匯入整個模組為物件
import * as mathUtils from './mathUtils.js';
const area = mathUtils.calculateCircleArea(5);

// 匯入特定函數
import { calculateCircleArea, Calculator } from './mathUtils.js';
const area2 = calculateCircleArea(5);
const calc = new Calculator();

// 帶別名的匯入
import { calculateDistance as dist } from './mathUtils.js';
const distance = dist(0, 0, 3, 4);

// 匯入預設匯出
import MathUtility from './mathUtils.js';
const factorial = MathUtility.factorial(5);

// 混合匯入
import MathUtility, { PI, calculateCircleArea } from './mathUtils.js';

// 動態匯入（類似 Python 的 importlib）
async function loadModule() {
    const module = await import('./mathUtils.js');
    return module.calculateCircleArea(5);
}
```
</PythonEditor>

## 錯誤處理

### 異常處理

<PythonEditor title="異常處理" compare={true}>
```python !! py
# Python 錯誤處理
def divide_numbers(a, b):
    try:
        result = a / b
        return result
    except ZeroDivisionError as e:
        print(f"錯誤：不能除以零 - {e}")
        return None
    except TypeError as e:
        print(f"錯誤：無效型別 - {e}")
        return None
    except Exception as e:
        print(f"意外錯誤：{e}")
        return None
    finally:
        print("除法操作完成")

# 多種異常型別
def parse_and_process(data):
    try:
        # 這可能引發 ValueError 或 KeyError
        number = int(data['value'])
        result = 100 / number
        return result
    except (ValueError, KeyError) as e:
        print(f"解析錯誤：{e}")
        return 0
    except ZeroDivisionError:
        print("不能除以零")
        return float('inf')
    else:
        print("操作成功")
    finally:
        print("清理完成")

# 引發自訂異常
class CustomError(Exception):
    def __init__(self, message):
        self.message = message
        super().__init__(self.message)

def validate_age(age):
    if not isinstance(age, int):
        raise TypeError("年齡必須是整數")
    if age < 0:
        raise ValueError("年齡不能為負數")
    if age > 150:
        raise CustomError("年齡似乎不現實")
    return True

# 使用上下文管理器（with 語句）
def read_file_safely(filename):
    try:
        with open(filename, 'r') as file:
            content = file.read()
            return content
    except FileNotFoundError:
        print(f"找不到檔案 {filename}")
        return None
    except PermissionError:
        print(f"拒絕存取 {filename}")
        return None
```

```javascript !! js
// JavaScript 錯誤處理
function divideNumbers(a, b) {
    try {
        if (b === 0) {
            throw new Error("不能除以零");
        }
        if (typeof a !== 'number' || typeof b !== 'number') {
            throw new TypeError("參數必須是數字");
        }
        
        const result = a / b;
        return result;
    } catch (error) {
        if (error instanceof TypeError) {
            console.log(`型別錯誤：${error.message}`);
        } else {
            console.log(`錯誤：${error.message}`);
        }
        return null;
    } finally {
        console.log("除法操作完成");
    }
}

// 處理不同錯誤型別
function parseAndProcess(data) {
    try {
        if (!data || typeof data !== 'object') {
            throw new Error("無效的資料物件");
        }
        
        if (!data.hasOwnProperty('value')) {
            throw new Error("缺少 'value' 屬性");
        }
        
        const number = parseInt(data.value);
        if (isNaN(number)) {
            throw new Error("值不是有效數字");
        }
        
        if (number === 0) {
            throw new Error("不能除以零");
        }
        
        const result = 100 / number;
        console.log("操作成功");
        return result;
    } catch (error) {
        console.log(`解析錯誤：${error.message}`);
        return 0;
    } finally {
        console.log("清理完成");
    }
}

// 自訂錯誤類別
class CustomError extends Error {
    constructor(message) {
        super(message);
        this.name = "CustomError";
    }
}

function validateAge(age) {
    if (typeof age !== 'number') {
        throw new TypeError("年齡必須是數字");
    }
    if (age < 0) {
        throw new RangeError("年齡不能為負數");
    }
    if (age > 150) {
        throw new CustomError("年齡似乎不現實");
    }
    return true;
}

// 非同步錯誤處理（Promise）
async function readFileSafely(filename) {
    try {
        // 模擬讀取檔案（在瀏覽器中，你會使用 fetch 或 FileReader）
        const response = await fetch(filename);
        if (!response.ok) {
            throw new Error(`HTTP 錯誤！狀態：${response.status}`);
        }
        const content = await response.text();
        return content;
    } catch (error) {
        if (error instanceof TypeError) {
            console.log(`網路錯誤：${error.message}`);
        } else {
            console.log(`讀取檔案錯誤：${error.message}`);
        }
        return null;
    }
}

// Promise 錯誤處理
fetch('/api/data')
    .then(response => {
        if (!response.ok) {
            throw new Error('網路回應不正常');
        }
        return response.json();
    })
    .then(data => console.log(data))
    .catch(error => console.error('Fetch 錯誤：', error))
    .finally(() => console.log('請求完成'));
```
</PythonEditor>

## 主要語法差異總結

### 需要記住的重大差異

<PythonEditor title="主要差異總結" compare={true}>
```python !! py
# Python 語法特徵

# 1. 縮排表示程式碼區塊
if True:
    print("縮排程式碼區塊")
    if True:
        print("巢狀縮排")

# 2. 不需要分號
x = 5
y = 10

# 3. 蛇形命名慣例
my_variable = "蛇形命名"
my_function_name = lambda: "函數"

# 4. 動態型別，無型別宣告
variable = "字串"
variable = 123
variable = [1, 2, 3]

# 5. 多重賦值和解包
a, b, c = 1, 2, 3
first, *rest = [1, 2, 3, 4]

# 6. 列表推導式
squares = [x**2 for x in range(5)]
filtered = [x for x in range(10) if x % 2 == 0]

# 7. 上下文管理器
with open('file.txt') as f:
    content = f.read()

# 8. 裝飾器
@property
def value(self):
    return self._value

# 9. 多重繼承
class Child(Parent1, Parent2):
    pass

# 10. 鴨子型別
def process_item(item):
    item.process()  # 如果 item 有 process 方法就能工作
```

```javascript !! js
// JavaScript 語法特徵

// 1. 大括號表示程式碼區塊
if (true) {
    console.log("大括號程式碼區塊");
    if (true) {
        console.log("巢狀大括號");
    }
}

// 2. 分號可選但建議使用
const x = 5;
const y = 10;

// 3. 駝峰命名慣例
const myVariable = "駝峰命名";
const myFunctionName = () => "函數";

// 4. 動態型別，可選型別宣告（TypeScript）
let variable = "字串";
variable = 123;
variable = [1, 2, 3];

// 5. 解構賦值
const [a, b, c] = [1, 2, 3];
const [first, ...rest] = [1, 2, 3, 4];

// 6. 陣列方法（類似推導式）
const squares = Array.from({length: 5}, (_, i) => i**2);
const filtered = Array.from({length: 10}, (_, i) => i)
    .filter(x => x % 2 === 0);

// 7. 沒有內建上下文管理器（使用 try-finally）
async function readFile() {
    let file;
    try {
        file = await openFile('file.txt');
        const content = await file.read();
        return content;
    } finally {
        if (file) await file.close();
    }
}

// 8. 沒有裝飾器（使用高階函數）
function property(target, key, descriptor) {
    // 類似裝飾器的功能
}

// 9. 原型繼承
class Child extends Parent {
    // 單一繼承，使用混入實現多重繼承
}

// 10. 鴨子型別同樣有效
function processItem(item) {
    item.process();  // 如果 item 有 process 方法就能工作
}
```
</PythonEditor>

## Python 開發者的最佳實踐

### 轉換建議

1. **擁抱 JavaScript 的事件驅動特性**: JavaScript 設計用於非同步、事件驅動程式設計
2. **理解範圍規則**: JavaScript 有函數範圍和區塊範圍（使用 `let`/`const`）
3. **使用現代 JavaScript 特性**: 偏好 `const`/`let` 而非 `var`，使用箭頭函數、解構
4. **掌握陣列方法**: `map()`、`filter()`、`reduce()` 替代許多 Python 列表推導式
5. **學習 Async/Await**: 回呼地獄和 Promise 鏈的現代替代方案
6. **使用 TypeScript**: 添加類似 Python 型別提示的靜態型別檢查
7. **理解 `this` 上下文**: Python 開發者最難理解的概念之一
8. **善用開發工具**: 使用 ESLint、Prettier 和現代 IDE 以獲得更好的開發體驗

### 常見陷阱

1. **相等比較**: 使用 `===` 而非 `==` 以避免型別強制轉換
2. **陣列/物件參考**: 物件和陣列是按參考傳遞
3. **提升**: 變數和函數宣告會被「提升」到其範圍頂部
4. **假值**: 與 Python 不同的假值（`0`、`""`、`null`、`undefined`、`false`、`NaN`）
5. **`this` 綁定**: 箭頭函數沒有自己的 `this` 上下文

這個全面的語法對比為從 Python 轉換到 JavaScript 提供了堅實的基礎。下一個模組將深入探討 JavaScript 的動態型別系統以及它與 Python 方法的差異。
